using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("GameState")]
	public class GameState : MonoClass
	{
		public enum ResponseMode
		{
			NONE,
			OPTION,
			SUB_OPTION,
			OPTION_TARGET,
			CHOICE
		}

		public enum CreateGamePhase
		{
			INVALID,
			CREATING,
			CREATED
		}

		[Attribute38("GameState.SelectedOption")]
		public class SelectedOption : MonoClass
		{
			public int m_main => method_2<int>("m_main");

			public int m_sub => method_2<int>("m_sub");

			public int m_target => method_2<int>("m_target");

			public int m_position => method_2<int>("m_position");

			public SelectedOption(IntPtr address, string className)
				: base(address, className)
			{
			}

			public SelectedOption(IntPtr address)
				: this(address, "SelectedOption")
			{
			}

			public void Clear()
			{
				method_8("Clear");
			}

			public void CopyFrom(SelectedOption original)
			{
				method_8("CopyFrom", original);
			}
		}

		[Attribute38("GameState.QueuedChoice")]
		public class QueuedChoice : MonoClass
		{
			public enum PacketType
			{
				ENTITY_CHOICES,
				ENTITIES_CHOSEN
			}

			public PacketType m_type => method_2<PacketType>("m_type");

			public object m_packet => method_3<object>("m_packet");

			public object m_eventData => method_3<object>("m_eventData");

			public QueuedChoice(IntPtr address, string className)
				: base(address, className)
			{
			}

			public QueuedChoice(IntPtr address)
				: this(address, "QueuedChoice")
			{
			}
		}

		public static int DEFAULT_SUBOPTION => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "GameState", "DEFAULT_SUBOPTION");

		public static string INDENT => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "GameState", "INDENT");

		public static float BLOCK_REPORT_START_SEC => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "GameState", "BLOCK_REPORT_START_SEC");

		public static float BLOCK_REPORT_INTERVAL_SEC => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "GameState", "BLOCK_REPORT_INTERVAL_SEC");

		public GameEntity m_gameEntity => method_3<GameEntity>("m_gameEntity");

		public CreateGamePhase m_createGamePhase => method_2<CreateGamePhase>("m_createGamePhase");

		public Network.HistTagChange m_realTimeGameOverTagChange => method_3<Network.HistTagChange>("m_realTimeGameOverTagChange");

		public bool m_gameOver => method_2<bool>("m_gameOver");

		public bool m_concedeRequested => method_2<bool>("m_concedeRequested");

		public bool m_restartRequested => method_2<bool>("m_restartRequested");

		public int m_maxSecretZoneSizePerPlayer => method_2<int>("m_maxSecretZoneSizePerPlayer");

		public int m_maxSecretsPerPlayer => method_2<int>("m_maxSecretsPerPlayer");

		public int m_maxQuestsPerPlayer => method_2<int>("m_maxQuestsPerPlayer");

		public int m_maxFriendlyMinionsPerPlayer => method_2<int>("m_maxFriendlyMinionsPerPlayer");

		public ResponseMode m_responseMode => method_2<ResponseMode>("m_responseMode");

		public List<Entity> m_chosenEntities => method_3<Class271<Entity>>("m_chosenEntities")?.method_25();

		public Network.Options m_options => method_3<Network.Options>("m_options");

		public SelectedOption m_selectedOption => method_3<SelectedOption>("m_selectedOption");

		public Network.Options m_lastOptions => method_3<Network.Options>("m_lastOptions");

		public SelectedOption m_lastSelectedOption => method_3<SelectedOption>("m_lastSelectedOption");

		public bool m_coinHasSpawned => method_2<bool>("m_coinHasSpawned");

		public Card m_friendlyCardBeingDrawn => method_3<Card>("m_friendlyCardBeingDrawn");

		public Card m_opponentCardBeingDrawn => method_3<Card>("m_opponentCardBeingDrawn");

		public int m_lastTurnRemindedOfFullHand => method_2<int>("m_lastTurnRemindedOfFullHand");

		public bool m_usingFastActorTriggers => method_2<bool>("m_usingFastActorTriggers");

		public PowerProcessor m_powerProcessor => method_3<PowerProcessor>("m_powerProcessor");

		public float m_reconnectIfStuckTimer => method_2<float>("m_reconnectIfStuckTimer");

		public float m_lastBlockedReportTimestamp => method_2<float>("m_lastBlockedReportTimestamp");

		public bool m_busy => method_2<bool>("m_busy");

		public bool m_mulliganBusy => method_2<bool>("m_mulliganBusy");

		public List<Spell> m_serverBlockingSpells => method_3<Class271<Spell>>("m_serverBlockingSpells")?.method_25();

		public List<SpellController> m_serverBlockingSpellControllers => method_3<Class271<SpellController>>("m_serverBlockingSpellControllers")?.method_25();

		public GameState(IntPtr address, string className)
			: base(address, className)
		{
		}

		public GameState(IntPtr address)
			: this(address, "GameState")
		{
		}

		public static GameState Get()
		{
			return MonoClass.smethod_15<GameState>(TritonHs.MainAssemblyPath, "", "GameState", "Get", Array.Empty<object>());
		}

		public static GameState Initialize()
		{
			return MonoClass.smethod_15<GameState>(TritonHs.MainAssemblyPath, "", "GameState", "Initialize", Array.Empty<object>());
		}

		public static void Shutdown()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "GameState", "Shutdown");
		}

		public static void FireGameStateInitializedEvent()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "GameState", "FireGameStateInitializedEvent");
		}

		public void Update()
		{
			method_8("Update");
		}

		public PowerProcessor GetPowerProcessor()
		{
			return method_14<PowerProcessor>("GetPowerProcessor", Array.Empty<object>());
		}

		public bool HasPowersToProcess()
		{
			return method_11<bool>("HasPowersToProcess", Array.Empty<object>());
		}

		public Entity GetEntity(int id)
		{
			return method_14<Entity>("GetEntity", new object[1] { id });
		}

		public Player GetPlayer(int id)
		{
			return method_14<Player>("GetPlayer", new object[1] { id });
		}

		public GameEntity GetGameEntity()
		{
			return method_14<GameEntity>("GetGameEntity", Array.Empty<object>());
		}

		public void DebugSetGameEntity(GameEntity gameEntity)
		{
			method_8("DebugSetGameEntity", gameEntity);
		}

		public bool WasGameCreated()
		{
			return method_11<bool>("WasGameCreated", Array.Empty<object>());
		}

		public Player GetFriendlySidePlayer()
		{
			return method_14<Player>("GetFriendlySidePlayer", Array.Empty<object>());
		}

		public Player GetOpposingSidePlayer()
		{
			return method_14<Player>("GetOpposingSidePlayer", Array.Empty<object>());
		}

		public int GetFriendlyPlayerId()
		{
			return method_11<int>("GetFriendlyPlayerId", Array.Empty<object>());
		}

		public int GetOpposingPlayerId()
		{
			return method_11<int>("GetOpposingPlayerId", Array.Empty<object>());
		}

		public bool IsFriendlySidePlayerTurn()
		{
			return method_11<bool>("IsFriendlySidePlayerTurn", Array.Empty<object>());
		}

		public Player GetCurrentPlayer()
		{
			return method_14<Player>("GetCurrentPlayer", Array.Empty<object>());
		}

		public Player GetFirstOpponentPlayer(Player player)
		{
			return method_14<Player>("GetFirstOpponentPlayer", new object[1] { player });
		}

		public int GetNumFriendlyMinionsInPlay(bool includeUntouchables)
		{
			return method_11<int>("GetNumFriendlyMinionsInPlay", new object[1] { includeUntouchables });
		}

		public int GetNumEnemyMinionsInPlay(bool includeUntouchables)
		{
			return method_11<int>("GetNumEnemyMinionsInPlay", new object[1] { includeUntouchables });
		}

		public int GetNumMinionsInPlay(Player player, bool includeUntouchables)
		{
			return method_11<int>("GetNumMinionsInPlay", new object[2] { player, includeUntouchables });
		}

		public int GetTurn()
		{
			return method_11<int>("GetTurn", Array.Empty<object>());
		}

		public bool IsResponsePacketBlocked()
		{
			return method_11<bool>("IsResponsePacketBlocked", Array.Empty<object>());
		}

		public void AddPlayer(Player player)
		{
			method_8("AddPlayer", player);
		}

		public void RemovePlayer(Player player)
		{
			method_8("RemovePlayer", player);
		}

		public void AddEntity(Entity entity)
		{
			method_8("AddEntity", entity);
		}

		public void RemoveEntity(Entity entity)
		{
			method_8("RemoveEntity", entity);
		}

		public int GetMaxSecretZoneSizePerPlayer()
		{
			return method_11<int>("GetMaxSecretZoneSizePerPlayer", Array.Empty<object>());
		}

		public int GetMaxSecretsPerPlayer()
		{
			return method_11<int>("GetMaxSecretsPerPlayer", Array.Empty<object>());
		}

		public int GetMaxQuestsPerPlayer()
		{
			return method_11<int>("GetMaxQuestsPerPlayer", Array.Empty<object>());
		}

		public int GetMaxFriendlyMinionsPerPlayer()
		{
			return method_11<int>("GetMaxFriendlyMinionsPerPlayer", Array.Empty<object>());
		}

		public bool IsBusy()
		{
			return method_11<bool>("IsBusy", Array.Empty<object>());
		}

		public void SetBusy(bool busy)
		{
			method_8("SetBusy", busy);
		}

		public bool IsMulliganBusy()
		{
			return method_11<bool>("IsMulliganBusy", Array.Empty<object>());
		}

		public void SetMulliganBusy(bool busy)
		{
			method_8("SetMulliganBusy", busy);
		}

		public bool IsMulliganManagerActive()
		{
			return method_11<bool>("IsMulliganManagerActive", Array.Empty<object>());
		}

		public bool IsTurnStartManagerActive()
		{
			return method_11<bool>("IsTurnStartManagerActive", Array.Empty<object>());
		}

		public bool IsTurnStartManagerBlockingInput()
		{
			return method_11<bool>("IsTurnStartManagerBlockingInput", Array.Empty<object>());
		}

		public bool HasTheCoinBeenSpawned()
		{
			return method_11<bool>("HasTheCoinBeenSpawned", Array.Empty<object>());
		}

		public void NotifyOfCoinSpawn()
		{
			method_8("NotifyOfCoinSpawn");
		}

		public bool IsBeginPhase()
		{
			return method_11<bool>("IsBeginPhase", Array.Empty<object>());
		}

		public bool IsPastBeginPhase()
		{
			return method_11<bool>("IsPastBeginPhase", Array.Empty<object>());
		}

		public bool IsMainPhase()
		{
			return method_11<bool>("IsMainPhase", Array.Empty<object>());
		}

		public bool IsMulliganPhase()
		{
			return method_11<bool>("IsMulliganPhase", Array.Empty<object>());
		}

		public bool IsMulliganPhasePending()
		{
			return method_11<bool>("IsMulliganPhasePending", Array.Empty<object>());
		}

		public bool IsMulliganPhaseNowOrPending()
		{
			return method_11<bool>("IsMulliganPhaseNowOrPending", Array.Empty<object>());
		}

		public CreateGamePhase GetCreateGamePhase()
		{
			return method_11<CreateGamePhase>("GetCreateGamePhase", Array.Empty<object>());
		}

		public bool IsGameCreating()
		{
			return method_11<bool>("IsGameCreating", Array.Empty<object>());
		}

		public bool IsGameCreated()
		{
			return method_11<bool>("IsGameCreated", Array.Empty<object>());
		}

		public bool IsGameCreatedOrCreating()
		{
			return method_11<bool>("IsGameCreatedOrCreating", Array.Empty<object>());
		}

		public bool WasConcedeRequested()
		{
			return method_11<bool>("WasConcedeRequested", Array.Empty<object>());
		}

		public void Concede()
		{
			method_8("Concede");
		}

		public bool WasRestartRequested()
		{
			return method_11<bool>("WasRestartRequested", Array.Empty<object>());
		}

		public void Restart()
		{
			method_8("Restart");
		}

		public void CheckRestartOnRealTimeGameOver()
		{
			method_8("CheckRestartOnRealTimeGameOver");
		}

		public bool IsGameOver()
		{
			return method_11<bool>("IsGameOver", Array.Empty<object>());
		}

		public bool IsGameOverPending()
		{
			return method_11<bool>("IsGameOverPending", Array.Empty<object>());
		}

		public bool IsGameOverNowOrPending()
		{
			return method_11<bool>("IsGameOverNowOrPending", Array.Empty<object>());
		}

		public Network.HistTagChange GetRealTimeGameOverTagChange()
		{
			return method_14<Network.HistTagChange>("GetRealTimeGameOverTagChange", Array.Empty<object>());
		}

		public void ShowEnemyTauntCharacters()
		{
			method_8("ShowEnemyTauntCharacters");
		}

		public Card GetFriendlyCardBeingDrawn()
		{
			return method_14<Card>("GetFriendlyCardBeingDrawn", Array.Empty<object>());
		}

		public void SetFriendlyCardBeingDrawn(Card card)
		{
			method_8("SetFriendlyCardBeingDrawn", card);
		}

		public Card GetOpponentCardBeingDrawn()
		{
			return method_14<Card>("GetOpponentCardBeingDrawn", Array.Empty<object>());
		}

		public void SetOpponentCardBeingDrawn(Card card)
		{
			method_8("SetOpponentCardBeingDrawn", card);
		}

		public bool IsBeingDrawn(Card card)
		{
			return method_11<bool>("IsBeingDrawn", new object[1] { card });
		}

		public bool ClearCardBeingDrawn(Card card)
		{
			return method_11<bool>("ClearCardBeingDrawn", new object[1] { card });
		}

		public int GetLastTurnRemindedOfFullHand()
		{
			return method_11<int>("GetLastTurnRemindedOfFullHand", Array.Empty<object>());
		}

		public void SetLastTurnRemindedOfFullHand(int turn)
		{
			method_8("SetLastTurnRemindedOfFullHand", turn);
		}

		public bool IsUsingFastActorTriggers()
		{
			return method_11<bool>("IsUsingFastActorTriggers", Array.Empty<object>());
		}

		public void SetUsingFastActorTriggers(bool enable)
		{
			method_8("SetUsingFastActorTriggers", enable);
		}

		public bool HasHandPlays()
		{
			return method_11<bool>("HasHandPlays", Array.Empty<object>());
		}

		public bool CanShowScoreScreen()
		{
			return method_11<bool>("CanShowScoreScreen", Array.Empty<object>());
		}

		public bool HasScoreLabels(Entity entity)
		{
			return method_11<bool>("HasScoreLabels", new object[1] { entity });
		}

		public void PreprocessRealTimeTagChange(Entity entity, Network.HistTagChange change)
		{
			method_8("PreprocessRealTimeTagChange", entity, change);
		}

		public void PreprocessTagChange(Entity entity, TagDelta change)
		{
			method_8("PreprocessTagChange", entity, change);
		}

		public void PreprocessEarlyConcedeTagChange(Entity entity, TagDelta change)
		{
			method_8("PreprocessEarlyConcedeTagChange", entity, change);
		}

		public void ProcessEarlyConcedeTagChange(Entity entity, TagDelta change)
		{
			method_8("ProcessEarlyConcedeTagChange", entity, change);
		}

		public void OnRealTimeGameOver(Network.HistTagChange change)
		{
			method_8("OnRealTimeGameOver", change);
		}

		public void OnGameOver(TAG_PLAYSTATE playState)
		{
			method_8("OnGameOver", playState);
		}

		public void OnCurrentPlayerChanged(Player player)
		{
			method_8("OnCurrentPlayerChanged", player);
		}

		public void OnTurnChanged(int oldTurn, int newTurn)
		{
			method_8("OnTurnChanged", oldTurn, newTurn);
		}

		public void AddServerBlockingSpell(Spell spell)
		{
			method_8("AddServerBlockingSpell", spell);
		}

		public bool RemoveServerBlockingSpell(Spell spell)
		{
			return method_11<bool>("RemoveServerBlockingSpell", new object[1] { spell });
		}

		public void AddServerBlockingSpellController(SpellController spellController)
		{
			method_8("AddServerBlockingSpellController", spellController);
		}

		public bool RemoveServerBlockingSpellController(SpellController spellController)
		{
			return method_11<bool>("RemoveServerBlockingSpellController", new object[1] { spellController });
		}

		public void DebugNukeServerBlocks()
		{
			method_8("DebugNukeServerBlocks");
		}

		public bool IsBlockingPowerProcessor()
		{
			return method_11<bool>("IsBlockingPowerProcessor", Array.Empty<object>());
		}

		public bool ShouldAdvanceReconnectIfStuckTimer()
		{
			return method_11<bool>("ShouldAdvanceReconnectIfStuckTimer", Array.Empty<object>());
		}

		public bool MustWaitForChoices()
		{
			return method_11<bool>("MustWaitForChoices", Array.Empty<object>());
		}

		public bool CanProcessPowerQueue()
		{
			return method_11<bool>("CanProcessPowerQueue", Array.Empty<object>());
		}

		public bool CheckReconnectIfStuck()
		{
			return method_11<bool>("CheckReconnectIfStuck", Array.Empty<object>());
		}

		public bool ReconnectIfStuck()
		{
			return method_11<bool>("ReconnectIfStuck", Array.Empty<object>());
		}

		public void ReportStuck()
		{
			method_8("ReportStuck");
		}

		public string BuildServerBlockingCausesString()
		{
			return method_13("BuildServerBlockingCausesString");
		}

		public void FireCreateGameEvent()
		{
			method_8("FireCreateGameEvent");
		}

		public void FireOptionsReceivedEvent()
		{
			method_8("FireOptionsReceivedEvent");
		}

		public void FireOptionsSentEvent(Network.Options.Option option)
		{
			method_8("FireOptionsSentEvent", option);
		}

		public void FireOptionRejectedEvent(Network.Options.Option option)
		{
			method_8("FireOptionRejectedEvent", option);
		}

		public void FireEntityChoicesReceivedEvent(Network.EntityChoices choices, PowerTaskList preChoiceTaskList)
		{
			method_8("FireEntityChoicesReceivedEvent", choices, preChoiceTaskList);
		}

		public bool FireEntitiesChosenReceivedEvent(Network.EntitiesChosen chosen)
		{
			return method_11<bool>("FireEntitiesChosenReceivedEvent", new object[1] { chosen });
		}

		public void FireTurnChangedEvent(int oldTurn, int newTurn)
		{
			method_8("FireTurnChangedEvent", oldTurn, newTurn);
		}

		public void FireFriendlyTurnStartedEvent()
		{
			method_8("FireFriendlyTurnStartedEvent");
		}

		public void FireTurnTimerUpdateEvent(TurnTimerUpdate update)
		{
			method_8("FireTurnTimerUpdateEvent", update);
		}

		public void FireCurrentPlayerChangedEvent(Player player)
		{
			method_8("FireCurrentPlayerChangedEvent", player);
		}

		public void FireGameOverEvent(TAG_PLAYSTATE playState)
		{
			method_8("FireGameOverEvent", playState);
		}

		public void FireHeroChangedEvent(Player player)
		{
			method_8("FireHeroChangedEvent", player);
		}

		public ResponseMode GetResponseMode()
		{
			return method_11<ResponseMode>("GetResponseMode", Array.Empty<object>());
		}

		public Network.EntityChoices GetFriendlyEntityChoices()
		{
			return method_14<Network.EntityChoices>("GetFriendlyEntityChoices", Array.Empty<object>());
		}

		public Network.EntityChoices GetOpponentEntityChoices()
		{
			return method_14<Network.EntityChoices>("GetOpponentEntityChoices", Array.Empty<object>());
		}

		public Network.EntityChoices GetEntityChoices(int playerId)
		{
			return method_14<Network.EntityChoices>("GetEntityChoices", new object[1] { playerId });
		}

		public bool IsChoosableEntity(Entity entity)
		{
			return method_11<bool>("IsChoosableEntity", new object[1] { entity });
		}

		public bool IsChosenEntity(Entity entity)
		{
			return method_11<bool>("IsChosenEntity", new object[1] { entity });
		}

		public bool AddChosenEntity(Entity entity)
		{
			return method_11<bool>("AddChosenEntity", new object[1] { entity });
		}

		public bool RemoveChosenEntity(Entity entity)
		{
			return method_11<bool>("RemoveChosenEntity", new object[1] { entity });
		}

		public List<Entity> GetChosenEntities()
		{
			return method_14<Class271<Entity>>("GetChosenEntities", Array.Empty<object>())?.method_25();
		}

		public Network.Options GetOptionsPacket()
		{
			return method_14<Network.Options>("GetOptionsPacket", Array.Empty<object>());
		}

		public void EnterChoiceMode()
		{
			method_8("EnterChoiceMode");
		}

		public void EnterMainOptionMode()
		{
			method_8("EnterMainOptionMode");
		}

		public void EnterSubOptionMode()
		{
			method_8("EnterSubOptionMode");
		}

		public void EnterOptionTargetMode()
		{
			method_8("EnterOptionTargetMode");
		}

		public void CancelCurrentOptionMode()
		{
			method_8("CancelCurrentOptionMode");
		}

		public bool IsInMainOptionMode()
		{
			return method_11<bool>("IsInMainOptionMode", Array.Empty<object>());
		}

		public bool IsInSubOptionMode()
		{
			return method_11<bool>("IsInSubOptionMode", Array.Empty<object>());
		}

		public bool IsInTargetMode()
		{
			return method_11<bool>("IsInTargetMode", Array.Empty<object>());
		}

		public bool IsInChoiceMode()
		{
			return method_11<bool>("IsInChoiceMode", Array.Empty<object>());
		}

		public void SetSelectedOption(int index)
		{
			method_9("SetSelectedOption", new Class276.Enum20[1] { Class276.Enum20.I4 }, index);
		}

		public int GetSelectedOption()
		{
			return method_11<int>("GetSelectedOption", Array.Empty<object>());
		}

		public void SetSelectedSubOption(int index)
		{
			method_8("SetSelectedSubOption", index);
		}

		public int GetSelectedSubOption()
		{
			return method_11<int>("GetSelectedSubOption", Array.Empty<object>());
		}

		public void SetSelectedOptionTarget(int target)
		{
			method_8("SetSelectedOptionTarget", target);
		}

		public int GetSelectedOptionTarget()
		{
			return method_11<int>("GetSelectedOptionTarget", Array.Empty<object>());
		}

		public bool IsSelectedOptionFriendlyHero()
		{
			return method_11<bool>("IsSelectedOptionFriendlyHero", Array.Empty<object>());
		}

		public bool IsSelectedOptionFriendlyHeroPower()
		{
			return method_11<bool>("IsSelectedOptionFriendlyHeroPower", Array.Empty<object>());
		}

		public void SetSelectedOptionPosition(int position)
		{
			method_8("SetSelectedOptionPosition", position);
		}

		public int GetSelectedOptionPosition()
		{
			return method_11<int>("GetSelectedOptionPosition", Array.Empty<object>());
		}

		public Network.Options.Option GetSelectedNetworkOption()
		{
			return method_14<Network.Options.Option>("GetSelectedNetworkOption", Array.Empty<object>());
		}

		public Network.Options.Option.SubOption GetSelectedNetworkSubOption()
		{
			return method_14<Network.Options.Option.SubOption>("GetSelectedNetworkSubOption", Array.Empty<object>());
		}

		public bool EntityHasSubOptions(Entity entity)
		{
			return method_11<bool>("EntityHasSubOptions", new object[1] { entity });
		}

		public bool EntityHasTargets(Entity entity)
		{
			return method_10<bool>("EntityHasTargets", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { entity });
		}

		public bool SubEntityHasTargets(Entity subEntity)
		{
			return method_11<bool>("SubEntityHasTargets", new object[1] { subEntity });
		}

		public bool HasSubOptions(Entity entity)
		{
			return method_11<bool>("HasSubOptions", new object[1] { entity });
		}

		public PlayErrors.ErrorType GetErrorType(Entity entity)
		{
			return method_11<PlayErrors.ErrorType>("GetErrorType", new object[1] { entity });
		}

		public bool HasResponse(Entity entity)
		{
			return method_11<bool>("HasResponse", new object[1] { entity });
		}

		public bool IsChoice(Entity entity)
		{
			return method_11<bool>("IsChoice", new object[1] { entity });
		}

		public bool IsValidOption(Entity entity)
		{
			return method_11<bool>("IsValidOption", new object[1] { entity });
		}

		public bool IsValidSubOption(Entity entity)
		{
			return method_11<bool>("IsValidSubOption", new object[1] { entity });
		}

		public bool IsValidOptionTarget(Entity entity, bool checkInputEnabled)
		{
			return method_11<bool>("IsValidOptionTarget", new object[2] { entity, checkInputEnabled });
		}

		public bool IsEntityInputEnabled(Entity entity)
		{
			return method_11<bool>("IsEntityInputEnabled", new object[1] { entity });
		}

		public bool EntityHasTargets(Entity entity, bool isSubEntity)
		{
			return method_10<bool>("EntityHasTargets", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Boolean
			}, new object[2] { entity, isSubEntity });
		}

		public void CancelSelectedOptionProposedMana()
		{
			method_8("CancelSelectedOptionProposedMana");
		}

		public void ClearResponseMode()
		{
			method_8("ClearResponseMode");
		}

		public void UpdateChoiceHighlights()
		{
			method_8("UpdateChoiceHighlights");
		}

		public void UpdateHighlightsBasedOnSelection()
		{
			method_8("UpdateHighlightsBasedOnSelection");
		}

		public void UpdateOptionHighlights()
		{
			method_9("UpdateOptionHighlights", new Class276.Enum20[0]);
		}

		public void UpdateOptionHighlights(Network.Options options)
		{
			method_9("UpdateOptionHighlights", new Class276.Enum20[1] { Class276.Enum20.Class }, options);
		}

		public void UpdateSubOptionHighlights(Network.Options.Option option)
		{
			method_8("UpdateSubOptionHighlights", option);
		}

		public void UpdateTargetHighlights(Network.Options.Option.SubOption subOption)
		{
			method_8("UpdateTargetHighlights", subOption);
		}

		public Network.Options GetLastOptions()
		{
			return method_14<Network.Options>("GetLastOptions", Array.Empty<object>());
		}

		public bool FriendlyHeroIsTargetable()
		{
			return method_11<bool>("FriendlyHeroIsTargetable", Array.Empty<object>());
		}

		public void ClearLastOptions()
		{
			method_8("ClearLastOptions");
		}

		public void ClearOptions()
		{
			method_8("ClearOptions");
		}

		public void ClearFriendlyChoices()
		{
			method_8("ClearFriendlyChoices");
		}

		public void OnSelectedOptionsSent()
		{
			method_8("OnSelectedOptionsSent");
		}

		public void OnTimeout()
		{
			method_8("OnTimeout");
		}

		public bool OnRealTimeFullEntity(Network.HistFullEntity fullEntity)
		{
			return method_11<bool>("OnRealTimeFullEntity", new object[1] { fullEntity });
		}

		public bool OnFullEntity(Network.HistFullEntity fullEntity)
		{
			return method_11<bool>("OnFullEntity", new object[1] { fullEntity });
		}

		public bool OnRealTimeShowEntity(Network.HistShowEntity showEntity)
		{
			return method_11<bool>("OnRealTimeShowEntity", new object[1] { showEntity });
		}

		public bool OnShowEntity(Network.HistShowEntity showEntity)
		{
			return method_11<bool>("OnShowEntity", new object[1] { showEntity });
		}

		public bool OnEarlyConcedeShowEntity(Network.HistShowEntity showEntity)
		{
			return method_11<bool>("OnEarlyConcedeShowEntity", new object[1] { showEntity });
		}

		public bool OnHideEntity(Network.HistHideEntity hideEntity)
		{
			return method_11<bool>("OnHideEntity", new object[1] { hideEntity });
		}

		public bool OnEarlyConcedeHideEntity(Network.HistHideEntity hideEntity)
		{
			return method_11<bool>("OnEarlyConcedeHideEntity", new object[1] { hideEntity });
		}

		public bool OnRealTimeChangeEntity(Network.HistChangeEntity changeEntity)
		{
			return method_11<bool>("OnRealTimeChangeEntity", new object[1] { changeEntity });
		}

		public bool OnChangeEntity(Network.HistChangeEntity changeEntity)
		{
			return method_11<bool>("OnChangeEntity", new object[1] { changeEntity });
		}

		public bool OnEarlyConcedeChangeEntity(Network.HistChangeEntity changeEntity)
		{
			return method_11<bool>("OnEarlyConcedeChangeEntity", new object[1] { changeEntity });
		}

		public bool OnRealTimeTagChange(Network.HistTagChange change)
		{
			return method_11<bool>("OnRealTimeTagChange", new object[1] { change });
		}

		public bool OnTagChange(Network.HistTagChange netChange)
		{
			return method_11<bool>("OnTagChange", new object[1] { netChange });
		}

		public bool OnEarlyConcedeTagChange(Network.HistTagChange netChange)
		{
			return method_11<bool>("OnEarlyConcedeTagChange", new object[1] { netChange });
		}

		public bool OnMetaData(Network.HistMetaData metaData)
		{
			return method_11<bool>("OnMetaData", new object[1] { metaData });
		}

		public void OnTaskListEnded(PowerTaskList taskList)
		{
			method_8("OnTaskListEnded", taskList);
		}

		public void OnReceivedEarlyConcede()
		{
			method_8("OnReceivedEarlyConcede");
		}

		public void OnAllOptions(Network.Options options)
		{
			method_8("OnAllOptions", options);
		}

		public void OnEntityChoices(Network.EntityChoices choices)
		{
			method_8("OnEntityChoices", choices);
		}

		public void OnEntitiesChosen(Network.EntitiesChosen chosen)
		{
			method_8("OnEntitiesChosen", chosen);
		}

		public bool CanProcessEntityChoices(Network.EntityChoices choices)
		{
			return method_11<bool>("CanProcessEntityChoices", new object[1] { choices });
		}

		public bool CanProcessEntitiesChosen(Network.EntitiesChosen chosen)
		{
			return method_11<bool>("CanProcessEntitiesChosen", new object[1] { chosen });
		}

		public void ProcessAllQueuedChoices()
		{
			method_8("ProcessAllQueuedChoices");
		}

		public void ProcessEntityChoices(Network.EntityChoices choices, PowerTaskList preChoiceTaskList)
		{
			method_8("ProcessEntityChoices", choices, preChoiceTaskList);
		}

		public void ProcessEntitiesChosen(Network.EntitiesChosen chosen)
		{
			method_8("ProcessEntitiesChosen", chosen);
		}

		public void OnGameSetup(Network.GameSetup setup)
		{
			method_8("OnGameSetup", setup);
		}

		public void OnOptionRejected(int optionId)
		{
			method_8("OnOptionRejected", optionId);
		}

		public void OnTurnTimerUpdate(Network.TurnTimerInfo info)
		{
			method_8("OnTurnTimerUpdate", info);
		}

		public void SendChoices()
		{
			method_8("SendChoices");
		}

		public void OnEntitiesChosenProcessed(Network.EntitiesChosen chosen)
		{
			method_8("OnEntitiesChosenProcessed", chosen);
		}

		public void SendOption()
		{
			method_8("SendOption");
		}

		public void OnTurnChanged_TurnTimer(int oldTurn, int newTurn)
		{
			method_8("OnTurnChanged_TurnTimer", oldTurn, newTurn);
		}

		public void TriggerTurnTimerUpdate(TurnTimerUpdate update)
		{
			method_8("TriggerTurnTimerUpdate", update);
		}

		public void DebugPrintPower(Logger logger, string callerName, Network.PowerHistory power)
		{
			method_9("DebugPrintPower", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.String,
				Class276.Enum20.Class
			}, logger, callerName, power);
		}

		public void DebugPrintTags(Logger logger, string callerName, string indentation, Network.Entity netEntity)
		{
			method_8("DebugPrintTags", logger, callerName, indentation, netEntity);
		}

		public void DebugPrintOptions()
		{
			method_8("DebugPrintOptions");
		}

		public void DebugPrintEntityChoices(Network.EntityChoices choices, PowerTaskList preChoiceTaskList)
		{
			method_8("DebugPrintEntityChoices", choices, preChoiceTaskList);
		}

		public void DebugPrintEntitiesChosen(Network.EntitiesChosen chosen)
		{
			method_8("DebugPrintEntitiesChosen", chosen);
		}

		public string GetEntityLogName(int id)
		{
			return method_13("GetEntityLogName", id);
		}
	}
}
